#include <iostream>
using std::cout;
using std::endl;

class A{
public:
    virtual void a(){ cout << "A::a()" << endl; } 
    void b(){ cout << "A::b()" << endl; } 
    virtual void c(){ cout << "A::c()" << endl; } 
    void e(){ cout << "A::e()" << endl; }
};

class B{
public:
    virtual void a(){ cout << "B::a()" << endl; } 
    void c(){ cout << "B::c()" << endl; } 
    void d(){ cout << "B::d()" << endl; } 
    virtual void f(){ cout << "B::f()" << endl; }
};

class C
: public A
, public B
{
public:
    virtual void a(){ cout << "C::a()" << endl; } 
    virtual void b(){ cout << "C::b()" << endl; } 
    void c(){ cout << "C::c()" << endl; } 
    void d(){ cout << "C::d()" << endl; } 
};

void test0(){
    C c;
    c.a(); //C::a() 没有通过虚函数表 理解为隐藏
    c.b(); //C::b() 没有通过虚函数表 理解为隐藏
    c.c(); //C::c() 没有通过虚函数表 理解为隐藏（对于C类，c函数是虚函数）
    c.d(); //C::d() 隐藏
    c.e(); //A::e() 通过A类基类子对象调用 
    c.f(); //B::f() 通过B类基类子对象调用
    
    cout << endl;
    A* pa = &c;
    pa->a();  //C::a() 动态多态
    pa->b();  //A::b() 对于A类b函数是普通成员函数
    pa->c();  //C::c() 动态多态
    /* pa->d(); //A类没有定义d函数，无法调用 */
    pa->e();  //A::e() 普通成员函数
    /* pa->f(); //A类没有定义f函数，无法调用 */
    
    cout << endl;
    B* pb = &c;
    pb->a(); //C::a() 动态多态 
    /* pb->b(); //B类没有定义b函数，无法调用 */
    pb->c(); //B::c() 对于B类c函数是普通成员函数
    pb->d(); //B::d() 对于B类d函数时普通成员函数
    /* pb->e(); //B类没有定义e函数，无法调用 */
    pb->f(); //B::f() 通过虚函数表，没有覆盖

    cout << endl;
    C * pc = &c;
    pc->a(); //C::a() 通过虚函数表 理解为隐藏
    pc->b(); //C::b() 通过虚函数表 理解为隐藏
    pc->c(); //C::c() 通过虚函数表，对于C类c函数是虚函数，理解为隐藏
    pc->d(); //C::d() 普通成员函数，隐藏
    pc->e(); //A::e() e函数对于A类是普通成员函数，不通过虚函数表
    pc->f(); //B::f() f函数对于B类是虚函数，C类没有覆盖，会通过虚函数表
}

int main(void){
    test0();
    return 0;
}
